5.13. Операторы и циклы

ДЛЯ НОВИЧКОВНЕ ДЛЯ НОВИЧКОВНЕ ОБЯЗАТЕЛЬНОВ РАЗРАБОТКЕ

Разработчику Архитектору

Операторы и циклы

Программирование на языке Rust строится на точном управлении данными, контроле над памятью и выражении логики через чёткие синтаксические конструкции. Две фундаментальные категории таких конструкций — операторы и циклы — образуют основу повседневной работы с кодом. Они позволяют выполнять вычисления, принимать решения, повторять действия и управлять потоком выполнения программы. В Rust эти механизмы реализованы с учётом принципов безопасности, производительности и предсказуемости поведения программы.

Общее понимание операторов

Оператор в Rust — это символ или комбинация символов, которая указывает компилятору выполнить определённое действие над одним или несколькими значениями. Эти действия могут быть арифметическими, логическими, побитовыми, сравнительными или управляющими. Каждый оператор имеет чётко определённый приоритет и ассоциативность, что позволяет однозначно интерпретировать сложные выражения без избыточных скобок.

Важно понимать, что в Rust почти всё является выражением. Это означает, что большинство конструкций возвращают значение, которое может быть использовано далее в программе. Однако операторы сами по себе не всегда являются выражениями. Некоторые из них, такие как присваивание или объявление переменной, не возвращают значений, доступных для последующего использования. Такие конструкции классифицируются как операторы-выражения или просто операторы, в зависимости от контекста.

Rust делит операторы на несколько категорий в зависимости от их назначения и количества операндов:

• Унарные операторы работают с одним операндом.
• Бинарные операторы требуют два операнда.
• Существуют также специальные формы, такие как операторы присваивания и составные операторы, которые сочетают в себе несколько действий.

Рассмотрим каждую группу подробно.

Арифметические операторы

Арифметические операторы в Rust предназначены для выполнения базовых математических операций: сложения, вычитания, умножения, деления и получения остатка от деления. Эти операторы работают с числовыми типами данных, такими как целые (i32, u64 и другие) и вещественные (f32, f64).

Сложение обозначается символом +. Например, выражение 5 + 3 возвращает значение 8. Вычитание использует символ -, умножение — *, деление — /. Все эти операции возвращают результат того же типа, что и операнды, при условии, что они совпадают по типу. Если типы различаются, требуется явное преобразование.

Особое внимание заслуживает оператор получения остатка от деления %. Он возвращает остаток после целочисленного деления одного числа на другое. Например, 10 % 3 даёт 1, потому что 10 делится на 3 три раза с остатком 1. Этот оператор особенно полезен при работе с циклическими структурами, проверке чётности чисел или распределении элементов по группам.

Все арифметические операции в Rust выполняются с проверкой на переполнение в режиме отладки. Если результат выходит за пределы допустимого диапазона типа, программа завершается с паникой. В релизной сборке такие проверки отключаются для повышения производительности, но разработчик может использовать специальные функции, такие как checked_add, если требуется безопасное поведение в любых условиях.

Операторы сравнения

Операторы сравнения позволяют сравнивать два значения и получать логический результат — true или false. В Rust поддерживаются следующие операторы сравнения:

• == — равенство
• != — неравенство
• < — меньше
• > — больше
• <= — меньше или равно
• >= — больше или равно

Эти операторы применимы к любым типам, реализующим соответствующие трейты, такие как PartialEq для равенства и PartialOrd для упорядочения. Большинство встроенных типов, включая числа, строки и булевы значения, уже реализуют эти трейты, поэтому их можно сравнивать напрямую.

Результат сравнения часто используется в условных выражениях и циклах для управления логикой программы. Например, конструкция if x > 10 { ... } выполняет блок кода только тогда, когда значение переменной x превышает 10.

Сравнение строк в Rust выполняется по содержимому, а не по адресу в памяти. Это означает, что две строки с одинаковыми символами считаются равными, даже если они хранятся в разных участках памяти. Такое поведение соответствует интуитивным ожиданиям и снижает вероятность ошибок.

Логические операторы

Логические операторы работают с булевыми значениями и позволяют строить сложные условия. Rust предоставляет три основных логических оператора:

• && — логическое И
• || — логическое ИЛИ
• ! — логическое НЕ

Оператор && возвращает true, только если оба операнда равны true. Оператор || возвращает true, если хотя бы один из операндов равен true. Оператор ! инвертирует значение: !true даёт false, а !false — true.

Важной особенностью логических операторов в Rust является ленивое вычисление (short-circuit evaluation). Это означает, что правый операнд не вычисляется, если результат уже определён по левому. Например, в выражении a && b, если a равно false, то b не будет вычисляться, потому что общий результат уже известен. Аналогично, в выражении a || b, если a равно true, то b игнорируется. Это поведение повышает эффективность и позволяет избегать ошибок, например, при проверке наличия значения перед обращением к нему.

Ленивое вычисление делает логические операторы удобным инструментом для построения безопасных и эффективных условий, особенно в связке с опциональными значениями и проверками границ.

Побитовые операторы

Побитовые операторы работают на уровне отдельных битов целочисленных значений. Они применяются реже, чем арифметические или логические, но незаменимы при низкоуровневом программировании, работе с аппаратными регистрами, шифрованием или оптимизации производительности.

Rust поддерживает следующие побитовые операторы:

• & — побитовое И
• | — побитовое ИЛИ
• ^ — побитовое исключающее ИЛИ (XOR)
• ! — побитовое НЕ (инверсия всех битов)
• << — сдвиг влево
• >> — сдвиг вправо

Операторы сдвига перемещают биты числа в указанном направлении. При сдвиге влево младшие биты заполняются нулями, а старшие теряются. При сдвиге вправо поведение зависит от знака числа: для беззнаковых типов (u32, u64) используются нули, для знаковых (i32, i64) — знаковый бит (арифметический сдвиг).

Побитовые операции часто используются для упаковки нескольких флагов в одно целое число, реализации масок или быстрого умножения и деления на степени двойки (через сдвиги).

Операторы присваивания

Оператор присваивания = используется для связывания значения с именем переменной. В Rust переменные по умолчанию неизменяемы, поэтому присваивание возможно только в том случае, если переменная была объявлена с ключевым словом mut.

Существуют также составные операторы присваивания, которые объединяют арифметическую или побитовую операцию с присваиванием:

• +=
• -=
• *=
• /=
• %=
• &=
• |=
• ^=
• <<=
• >>=

Например, запись x += 5 эквивалентна x = x + 5. Эти операторы удобны для сокращения кода и повышения его читаемости. Они требуют, чтобы переменная была изменяемой, иначе компилятор выдаст ошибку.

Операторы как выражения

В Rust многие операторы возвращают значения и могут использоваться внутри других выражений. Например, можно написать:

let y = {
    let x = 3;
    x + 1
};

Здесь блок { ... } является выражением, и его результат — значение 4 — присваивается переменной y. Аналогично, арифметические и логические операторы возвращают результат, который может быть частью более сложного выражения.

Однако оператор присваивания = сам по себе не возвращает полезного значения. Его тип — () (unit type), что означает «отсутствие значения». Это сделано намеренно, чтобы избежать распространённой ошибки из других языков, где случайное использование = вместо == в условии приводит к неожиданному поведению. В Rust такое условие не скомпилируется, если только не используется специальный синтаксис.

---

Циклы в Rust: повторение без компромиссов

Циклы в Rust — это конструкции, предназначенные для многократного выполнения блока кода до тех пор, пока выполняется определённое условие или не исчерпан набор данных. В отличие от многих других языков, где циклы часто связаны с рисками переполнения, утечек памяти или гонок данных, Rust обеспечивает безопасность даже в самых сложных сценариях итерации. Это достигается за счёт глубокой интеграции циклов с моделью владения, проверками времени жизни и строгой типизацией.

Rust предоставляет три основные формы циклов:

• loop — бесконечный цикл, прерываемый явно;
• while — цикл с предусловием;
• for — цикл по итератору.

Каждая из этих форм имеет чёткое назначение, предсказуемое поведение и минимальные накладные расходы. Ни одна из них не требует ручного управления памятью, а все операции внутри цикла подчиняются тем же правилам безопасности, что и остальной код программы.

Бесконечный цикл loop

Самый простой и фундаментальный цикл в Rust — это loop. Он представляет собой бесконечную последовательность повторений, которая продолжается до тех пор, пока не будет явно прервана с помощью ключевого слова break.

loop {
    println!("Это будет печататься вечно...");
    break; // Без этого цикл действительно будет бесконечным
}

Хотя на первый взгляд такой цикл может показаться примитивным, он играет важную роль в системном программировании, реализации событийных циклов, игровых движков, сетевых серверов и других сценариев, где логика завершения не сводится к простому условию. Например, сервер может использовать loop для постоянного ожидания входящих соединений, а каждое соединение обрабатывается внутри тела цикла.

Особенность loop в том, что он может возвращать значение. Это достигается путём указания выражения после break:

let result = loop {
    let x = some_computation();
    if x > 100 {
        break x * 2;
    }
};

В этом примере переменная result получит значение, вычисленное при выходе из цикла. Такой подход позволяет инкапсулировать логику поиска или ожидания внутри цикла и передавать результат напрямую, без использования дополнительных переменных.

Условный цикл while

Цикл while выполняет тело до тех пор, пока заданное логическое выражение остаётся истинным. Проверка условия происходит перед каждой итерацией, поэтому если условие изначально ложно, тело цикла не выполнится ни разу.

let mut counter = 0;
while counter < 5 {
    println!("Счётчик: {}", counter);
    counter += 1;
}

Этот цикл удобен, когда количество итераций заранее неизвестно, но существует чёткий критерий завершения — например, ожидание ввода пользователя, чтение данных из потока до конца или обработка состояния, которое изменяется во время выполнения.

Важно отметить, что использование while с индексами для обхода коллекций считается антипаттерном в Rust. Такой подход подвержен ошибкам (например, выходу за границы массива) и менее эффективен, чем итерация через итераторы. Компилятор не запрещает его, но экосистема и сообщество настоятельно рекомендуют использовать for в подобных случаях.

Итерационный цикл for

Цикл for в Rust — это не просто синтаксический сахар для инкрементного счётчика. Он является универсальным механизмом итерации по любым типам, реализующим трейт IntoIterator. Это включает массивы, векторы, диапазоны, строки, хэш-карты и пользовательские коллекции.

Простейший пример — итерация по диапазону:

for i in 1..=5 {
    println!("{}", i);
}

Здесь 1..=5 — это включающий диапазон от 1 до 5. Если бы использовался 1..5, цикл выполнился бы для значений от 1 до 4.

Итерация по вектору:

let numbers = vec![10, 20, 30];
for num in numbers {
    println!("{}", num);
}

В этом случае переменная num получает владение каждым элементом вектора. После завершения цикла сам вектор numbers становится недоступным, потому что его содержимое было перемещено в тело цикла. Это следствие модели владения: данные не копируются без необходимости, а передаются напрямую.

Если требуется только чтение элементов без передачи владения, используется заимствование:

let numbers = vec![10, 20, 30];
for num in &numbers {
    println!("{}", num);
}
// numbers всё ещё доступен здесь

Аналогично, можно получить изменяемые ссылки с помощью &mut.

Для получения одновременно индекса и значения применяется метод .enumerate():

let fruits = ["яблоко", "банан", "апельсин"];
for (index, fruit) in fruits.iter().enumerate() {
    println!("{}: {}", index, fruit);
}

Этот подход сочетает удобство и безопасность: индекс всегда корректен, выход за границы невозможен, а память управляется автоматически.

Управление потоком внутри циклов: break и continue

Rust предоставляет два ключевых слова для управления выполнением циклов:

• break — немедленно прекращает выполнение цикла;
• continue — прерывает текущую итерацию и переходит к следующей.

Оба они работают во всех трёх формах циклов. Кроме того, Rust поддерживает метки (labels) для вложенных циклов, что позволяет точно указать, какой цикл должен быть прерван или продолжен:

'outer: for x in 0..3 {
    'inner: for y in 0..3 {
        if x == 1 && y == 1 {
            break 'outer;
        }
        println!("({}, {})", x, y);
    }
}

Без метки break прервал бы только внутренний цикл. С меткой 'outer — внешний. Это мощный, но редко используемый механизм, который сохраняет читаемость даже в сложных вложенных структурах.

Циклы и безопасность памяти

Одна из ключевых особенностей Rust — отсутствие неопределённого поведения при работе с памятью. Эта гарантия распространяется и на циклы. Например, попытка изменить коллекцию во время её итерации приведёт к ошибке компиляции:

let mut vec = vec![1, 2, 3];
for item in &vec {
    vec.push(*item); // Ошибка: нельзя одновременно заимствовать как неизменяемую и изменяемую ссылку
}

Такое поведение предотвращает целый класс ошибок, известных в других языках как «итерация по изменяющейся коллекции». Rust не полагается на документацию или дисциплину разработчика — он делает такие ошибки невозможными на этапе компиляции.

Производительность циклов

Циклы в Rust компилируются в высокоэффективный машинный код, сравнимый с C или C++. Это достигается благодаря:

• отсутствию накладных расходов на сборку мусора;
• агрессивной оптимизации со стороны LLVM;
• возможности инлайнинга итераторов;
• отсутствию проверок границ в релизной сборке при использовании безопасных идиом (например, .get() заменяется на прямой доступ, если компилятор доказывает безопасность).

На практике идиоматичный Rust-код с for и итераторами часто оказывается быстрее, чем аналогичный код с ручным управлением индексами, поскольку компилятор лучше понимает намерения программиста и может применять более глубокие оптимизации.

---

Итераторы: основа повторяющихся вычислений

В Rust цикл for — это не примитивный синтаксический элемент, а удобная обёртка над мощной системой итераторов. Итератор представляет собой объект, который последовательно выдаёт элементы из некоторого источника: коллекции, диапазона, файла, сети или даже генератора. Эта модель позволяет отделить логику получения данных от логики их обработки, что повышает модульность, читаемость и переиспользуемость кода.

Любой тип, реализующий трейт Iterator, может быть использован в цикле for. Трейт Iterator требует реализации одного метода — next(), который возвращает Option<Self::Item>. Значение Some(item) означает, что следующий элемент доступен, а None сигнализирует об окончании последовательности.

Благодаря этой унификации, разработчик может писать один и тот же код для обхода массивов, строк, файлов, каналов или пользовательских структур данных — без изменения логики обработки.

Создание и использование итераторов

Итераторы создаются вызовом методов, таких как .iter(), .into_iter(), .chars(), .lines() или просто через диапазоны:

let v = vec![1, 2, 3];
let mut iter = v.iter(); // возвращает итератор по ссылкам

Метод .iter() заимствует элементы, .into_iter() передаёт владение, а .iter_mut() предоставляет изменяемые ссылки. Выбор метода определяет, будет ли исходная коллекция доступна после итерации и можно ли изменять её содержимое.

Цикл for автоматически вызывает .into_iter() на правом операнде, поэтому запись:

for x in collection { ... }

эквивалентна:

for x in collection.into_iter() { ... }

Это позволяет использовать одну и ту же синтаксическую конструкцию для разных режимов владения, сохраняя семантическую ясность.

Комбинаторы итераторов: функциональный подход к потокам данных

Rust предоставляет богатый набор комбинаторов итераторов — методов, которые преобразуют, фильтруют, объединяют или агрегируют данные без немедленного выполнения. Такие операции являются ленивыми: они не вычисляются до тех пор, пока не будет вызван «потребляющий» метод, такой как .collect(), .fold() или явный цикл.

Некоторые из наиболее часто используемых комбинаторов:

• .map(f) — применяет функцию f к каждому элементу;
• .filter(p) — оставляет только те элементы, для которых предикат p возвращает true;
• .take(n) — ограничивает количество элементов до n;
• .skip(n) — пропускает первые n элементов;
• .enumerate() — добавляет индекс к каждому элементу;
• .zip(other) — объединяет два итератора в пары;
• .fold(init, f) — сворачивает последовательность в одно значение, начиная с init.

Пример композиции:

let result: Vec<i32> = (1..10)
    .filter(|x| x % 2 == 0)
    .map(|x| x * x)
    .collect();
// result = [4, 16, 36, 64]

Этот код читается как последовательность трансформаций: сначала берутся числа от 1 до 9, затем отбираются чётные, после чего каждое возводится в квадрат, и результат собирается в вектор. Такой стиль программирования близок к декларативному: он описывает что нужно сделать, а не как это сделать шаг за шагом.

Компилятор Rust оптимизирует такие цепочки, устраняя промежуточные аллокации и встраивая функции напрямую. В результате производительность такого кода часто сравнима с ручным циклом, но при этом он значительно безопаснее и выразительнее.

Потребление итераторов: когда вычисления становятся реальными

Ленивость итераторов означает, что создание цепочки .map().filter().take() не приводит к немедленной обработке данных. Вычисления запускаются только при вызове метода, который «потребляет» итератор:

• .collect() — собирает все элементы в коллекцию (например, Vec, String, HashSet);
• .fold() — сворачивает последовательность в одно значение;
• .for_each() — выполняет побочный эффект для каждого элемента;
• .last(), .nth(), .find() — извлекают конкретные элементы;
• .count() — подсчитывает количество элементов.

Выбор потребляющего метода определяет, как будет использован результат итерации. Например, если требуется только проверить наличие хотя бы одного подходящего элемента, достаточно вызвать .any(|x| condition), и итерация прекратится сразу после первого совпадения.

Обработка ошибок в итераторах

Итераторы в Rust могут работать с типами, содержащими ошибки, такими как Result<T, E>. Для этого существуют специальные комбинаторы:

• .collect::<Result<Vec<_>, _>>() — собирает все Ok значения, но прерывается и возвращает первую Err;
• .filter_map() — преобразует и одновременно отфильтровывает, возвращая Option;
• .try_for_each() — выполняет действие для каждого элемента, но останавливается при первой ошибке.

Эти инструменты позволяют естественно интегрировать обработку ошибок в потоки данных, не нарушая линейности кода и не прибегая к вложенным match или if let.

Итераторы и владение: гарантии безопасности

Модель владения Rust проявляется и в работе с итераторами. Невозможно одновременно иметь изменяемый итератор и неизменяемую ссылку на коллекцию. Невозможно получить доступ к элементу по индексу, если коллекция уже передана во владение итератору. Эти ограничения обеспечивают отсутствие гонок данных, двойного освобождения памяти и использования после освобождения — даже в многопоточной среде.

Кроме того, итераторы не хранят внутренние указатели на данные после завершения. Они либо владеют данными, либо заимствуют их на время, ограниченное временем жизни ('a). Это делает их совместимыми с системой проверки времени жизни и исключает утечки.

Асинхронные итераторы: будущее повторяющихся операций

Хотя стандартная библиотека Rust на момент 2026 года не включает встроенную поддержку асинхронных итераторов, экосистема предлагает решения через крейты, такие как futures и tokio-stream. Асинхронный итератор (Stream) — это аналог Iterator, но его метод next() возвращает Poll<Option<T>> или Pin<Box<dyn Future<Output = Option<T>>>>, в зависимости от реализации.

Асинхронные циклы записываются с помощью while let Some(item) = stream.next().await { ... }, а в будущем могут получить синтаксическую поддержку в виде for await. Это открывает путь к эффективной обработке потоков данных из сетевых соединений, баз данных или сенсоров без блокировки выполнения.

---